{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    !pip install gym[all]\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02. Double DQN\n",
    "\n",
    "[van Hasselt et al., \"Deep Reinforcement Learning with Double Q-learning.\" arXiv preprint arXiv:1509.06461, 2015.](https://arxiv.org/pdf/1509.06461.pdf)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Let's take a close look at the difference between DQN and Double-DQN. The max operator in standard Q-learning and DQN uses the same values both to select and to evaluate an action. This makes it more likely to select overestimated values, resulting in overoptimistic value estimates.\n",
    "\n",
    "$$\n",
    "\\theta_{t+1} = \\theta_t + \\alpha \\big(Y_t^Q - Q(S_t, A_t; \\theta_t)\\big) \\cdot \\nabla_{\\theta_t} Q(S_t, A_t; \\theta_t),\\\\\n",
    "\\text{where } \\alpha \\text{ is a scalar step size and the target } Y_t^Q \\text{is defined as }\\\\\n",
    "Y_t^Q = R_{t+1} + \\gamma \\max_a Q(S_{t+1}, a; \\theta_t).\n",
    "$$\n",
    "\n",
    "In Double Q-learning ([van Hasselt 2010](https://papers.nips.cc/paper/3964-double-q-learning.pdf)), two value functions are learned by assigning experiences randomly to update one of the two value functions, resulting in two sets of weights, $\\theta$ and $\\theta'$. For each update, one set of weights is used to determine the greedy policy and the other to determine its value. For a clear comparison, we can untangle the selection and evaluation in Q-learning and rewrite DQN's target as\n",
    "\n",
    "$$\n",
    "Y_t^Q = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t).\n",
    "$$\n",
    "\n",
    "The Double Q-learning error can then be written as\n",
    "\n",
    "$$\n",
    "Y_t^{DoubleQ} = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t').\n",
    "$$\n",
    "\n",
    "The idea of Double Q-learning is to reduce overestimations by decomposing the max operation in the target into action selection and action evaluation. Although not fully decoupled, the target network in the DQN architecture provides a natural candidate for the second value function, without having to introduce additional networks. In conclusion, the weights of the second network $\\theta_t'$ are replaced with the weights of the target network for the evaluation of the current greedy policy. This makes just a small change in calculating the target value of DQN loss.\n",
    "\n",
    "##### DQN:\n",
    "\n",
    "```\n",
    "target = reward + gamma * dqn_target(next_state).max(dim=1, keepdim=True)[0]\n",
    "```\n",
    "\n",
    "##### DoubleDQN:\n",
    "\n",
    "```\n",
    "selected_action = dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "target = reward + gamma * dqn_target(next_state).gather(1, selected_action)\n",
    "```\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Double DQN Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "We use `self.dqn` instead of `self.dqn_target` for action selection.\n",
    "\n",
    "```\n",
    "\n",
    "        next_q_value = self.dqn_target(next_state).gather(\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)  # Double DQN\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> List[np.ndarray]:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).gather(  # Double DQN\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)\n",
    "if IN_COLAB:\n",
    "    env = gym.wrappers.Monitor(env, \"videos\", force=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 200\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if IN_COLAB:  # for colab\n",
    "    import base64\n",
    "    import glob\n",
    "    import io\n",
    "    import os\n",
    "\n",
    "    from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "    def ipython_show_video(path: str) -> None:\n",
    "        \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "        if not os.path.isfile(path):\n",
    "            raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "        video = io.open(path, \"r+b\").read()\n",
    "        encoded = base64.b64encode(video)\n",
    "\n",
    "        display(HTML(\n",
    "            data=\"\"\"\n",
    "            <video alt=\"test\" controls>\n",
    "            <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "            </video>\n",
    "            \"\"\".format(encoded.decode(\"ascii\"))\n",
    "        ))\n",
    "\n",
    "    list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    print(latest_file)\n",
    "    ipython_show_video(latest_file)\n",
    "    \n",
    "else:  # for jupyter\n",
    "    from matplotlib import animation\n",
    "    from JSAnimation.IPython_display import display_animation\n",
    "    from IPython.display import display\n",
    "\n",
    "\n",
    "    def display_frames_as_gif(frames: List[np.ndarray]) -> None:\n",
    "        \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "        patch = plt.imshow(frames[0])\n",
    "        plt.axis('off')\n",
    "\n",
    "        def animate(i):\n",
    "            patch.set_data(frames[i])\n",
    "\n",
    "        anim = animation.FuncAnimation(\n",
    "            plt.gcf(), animate, frames = len(frames), interval=50\n",
    "        )\n",
    "        display(display_animation(anim, default_mode='loop'))\n",
    "\n",
    "\n",
    "    # display \n",
    "    display_frames_as_gif(frames)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
